#win32 program

[ralfmaximus]

In regards to the Windows 10 LTSC thing, the caveat is that it uses build 19044 (version 21H2), so it's very likely that certain programs simply won't be compatible with it

Additionally, one article said that even if they do push out a new LTSC version, there's no way to simply upgrade, you have to reinstall the whole OS just to get that new version. There's also conflicting information that it doesn't need a product key, but if it does, then you have to get it through enterprise vendors who may or may not be willing to sell you a key for a single device (or a small batch of devices, ex: 5)

It could very well be an option for some people to ride out W10 for a little longer, but these are just some things to bear in mind

Thanks for your note! It's clear you've thought about this.

The compatibility thing gets thrown around a lot, but honestly one thing Microsoft gets right with Windows is backwards compatibility. I write software for a living and one aspect of my job is retrotesting new builds of my stuff on older platforms. Currently, everything I do works on Win11 back to WinXP.

Of course, companies can choose to break compatibility. Steam famously stopped working on Win7 awhile back, forcing users to upgrade. But the core Win32 API hasn't changed in 30+ years which is remarkable.

Assuming your software doesn't need the latest build of Windows... why bother?

Bottom line, I personally am not worried about not being able to install something. When's the last time that happened with you?

If you treat Windows as a program launcher (which it is) instead of an ecosystem (which it also is, because Microsoft wants you to live there and pay them $$$) then the 'problem' becomes simpler: will the programs YOU want to run work with an old build of Win10? If so, there's no need to upgrade.

Microsoft has successfully created a religion around Windows Update. You MUST have the latest patches! Otherwise, you are VULNERABLE. Bad Things will Happen if you Don't Upgrade! Be afraid!!

That is simply not true. In my living room I drive our big screen TV with an ancient Dell box (circa 2009) running Win7 and Media Player Classic (MPC). It plays TV shows & movies just fine, exceeding DVD & Bluray resolutions. It hasn't received a Windows Update in a decade, but continues to chug along reliably. I installed Malware Bytes to make up for Windows Defender being out of date, since it has Firefox installed and we do use it to noodle around on the web occasionally. Youtube on a big screen is fun.

Will I ever upgrade that Windows? Probably not. Maybe if the host Dell Optiplex (2009!!) ever dies but otherwise... why would I?

My main workstation is Win10 and I plan to ride this thing until it explodes. Win11 is super annoying, and all the machines I run Win11 on are infested with Copilot and nag screens about OneDrive. I recently downgraded Office 365 to Office 2016 for that very reason.

Sense a pattern here?

tl;dr: Win10, even the older builds, are adequate for the typical user, for the foreseeable future. Installing & activation are stupidly easy. No product keys needed.

Finally: if you're nervous about Win10 there exist stripped down enterprise builds of Win11 available as well.

[nhaneh]

@lynxden assuming you meant cpu and not gpu then yes xD

it's basically some of the most memorable and fun moments I've had learning programming has been about doing things the Hard Way™ - doing things manually tends to require you to spend more time thinking about what the computer's actually doing to accomplish the things you ask it to do, which is inevitably a lot more work and often nowhere near as efficient or capable because it's pretty unlikely that you just happen to be smarter than the entire R&D teams they have at Nvidia or Unreal or wherever - but it does force you to learn stuff, at least on a temporary basis.

I mean look, when I first learned how to do proper programming that wasn't just faffing around in Qbasic or whatever, it was on Turbo Pascal in DOS some 25-odd years ago, and I'm kind of forever grateful that when it came to doing graphics, instead of just having us use the built in Borland Graphics API, the teacher taught us how to enter VGA mode 0x13 via direct DOS interrupts, and then how to draw graphics by writing directly to the part of memory that held the screen for that mode.

I still remember the address being 0xA000.

So when I decided I really should take another stab at trying to figure out how the hells matrices work for 2D and 3D transformations a few weeks back, I thought hey why not try doing all of this directly using the Win32 GDI API, BitBlt:ing a framebuffer into the graphics because then I'll also have to re-learn a bunch of stuff that I've more or less forgotten over the years. Plus, there's a part of me that kind of wants to try to take some time to learn at least a little more about software reverse engineering - see if I could ever get to a point where I might be able to look into whether some examples of old games or software that doesn't work so well anymore could be updated to work a bit better.

So, step by step I'm gradually working my way towards a software triangle rasteriser to see about poking around with all of that and I dunno maybe I'll make something small and simple out of it like maybe some vampire survivors-alike or something like the original after burner or maybe even descent or something, who knows.

For now it's mostly a whole lot of googling around, trying to wrap my brain around stuff that feels like I used to find it easier to understand than I do now, and basically just reminding myself why I liked doing some of this stuff, haha.

[sweetheartmagic]

COMPUTER VIRUS RANTS ARE BACK!!

today we're gonna be learning about worms. actually, the first couple of worms!

EMAIL-WIN32.HAPPY99

happy99 is seemed to be the first computer worm of the new age of windows, spread on the new world wide web! how fun! can you guess when this virus was out. 1999. both spread through email and netgroups. when happy99 is run, it will display a popup with fireworks on it. and with this popup, comes it infecting a program called Wsock32.dll, a commutation library to look at all the activity and traffic on the network. when an email is sent, or something is posted, happy99 would attach itself to those posts and emails. other than that, it doesn't do anything! a pretty innocent, happy little guy.

THE CREEPER is up next because. Y'know. Worms

this is the first worm Ever. created in 1971, the creeper was harmless. it was designed as a test to see if self reciprocating and spreading programs were possible. it did nothing besides display a message to the teletype.

well, that concludes todays worms and viruses. sorry this is the first one I've done in a while.

[brandinotbroke]

I did the DEP fix on my pc and I haven't gotten any crashes yet but I've gotten pink code along with this on the cheat console (I had a lot of messages saying this there): WARNING D3D Error: Bad return code, is this normal? : D3DERR_INVALIDCALL C:\dev\sims 2 remaster\DL\GZFrame\Graphic\GZGraphic4\Win32\source\GZGraphic4ShaderProgramDX.cpp(435)4

Hi! Any file ending with .cpp is a source code file. So we can gather that there is a bad return code/invalid call error concerning Direct3D (which is Microsoft's DirectX programming interface) and something that is in the game's shader code. We don't have access to the source code, so I don't know what exactly the issue is here.

So this is basically what I've been saying all along. It looks like the game is doing something "illegal" when rendering things (meaning it is not strictly following the rules of DirectX), and this is what potentially causes pink flashing. But as long as we don't have access to this source code, there is nothing we can do about it.

And there is a big fat BUT: There is no guarantee that this error has anything to do with the pink flashing either. It could also be coincidence, since errors aren't necessarily always visible. For example, if you open your browser's developer tools, there will be a bunch of red errors there too, but you just don't notice them because the program handles them automatically.

[q4os-tde-official]

found a very cool piece of software called Windhawk (basically a mod manager for modding Windows itself) and i've been using it to customise Windows

Changes i've made (using both Windhawk and other software):

Rethemed the taskbar to make it look more like a plasma-esque dock

Replacing the start menu

Outright disabling the search UI and replacing it with Command Palette (including giving it the Win + S shortcut)

Rethemed the notification center

Rethemed the Taskbar icon right-click menu

Forced File Explorer to show the size of folder contents

Made Win32 programs translucent

Made it so that i can adjust volume by scrolling on the taskbar

[wind-up-thancred]

SO i've been digging around in the benchmark files with xiv data explorer...

...and with my middling knowledge of how XIV's current texture types work, i've noticed some differences in how texture channels have worked and what data is stored where. i haven't figured out what EVERYTHING'S for yet and if you think you have an idea or any corrections, pls feel free to lmk. could help with figuring out 7.0 modding quicker! this is also decent info for figuring out what old mods can be repurposed for 7.0 graphics.

also content warning for unwrapped face textures under the cut, i know those can look kind of spooky if you arent used to 'em lol

starting off, i didn't source this info but chirp (known plugin dev) on twitter talked about finding about fifty six new bones in the facial armature specifically. this means things like sculpts will probably be unusable unless they are manually re-rigged with each one of those fifty six new bones, or else they wont animate properly.

the default UV maps for the face specifically have changed, too, and many of the uses of the old normal and multi channels have been changed or moved to a different texture. NOTE that these examples were found from au ra textures, male specifically, and the channels may or may not have different uses on non-scaled races!

old vs new multi map. i'm fairly certain every channel here has been repurposed: for example, blue used to be for lipstick, now it seems to be for something else. so where'd the lipstick area data go? well:

it's been moved to the alpha channel on the normal map (these are both the new one). additionally, it seems like the blue channel on the normal map has been changed to signify the difference between skin and non-skin or something of the like.

(old vs new) similarly, even though the body seems to use the same UV layout with a redefined normal map, the blue channel here also seems to indicate skin vs non-skin. but the blue channel used to be for transparency (iirc?), so where is that data stored now?

the transparency data seems to have been moved to the alpha channel of the diffuse now. this image is part of the new face diffuse.

like the face multi map, the body multi map seems to actually use the blue channel now (and looks SO much cleaner, wow!). old vs new.

so what do these changes mean for our current mods?

-due to changed UVs, existing makeups will not be usable with the new faces UNLESS someone goes through the effort of taking the old sculpt (vanilla or otherwise) and weight paints ALL the new face bones to them, or somehow adjusts the UV mapping on the new sculpt to match the old one. i don't work with sculpts so i'm not sure how feasible either of these are

-existing body tattoo mods that only affect the diffuse should theoretically still work fine, as the UVs have not been changed on the body. body scale mods that are just recolors should work fine as well, but matching face scale mods will have to be redone for the new UVs.

-however, if it's a scale mod like dragonborn that changes the placement of the scales and therefore the normal and multi maps, those will have to be adjusted to match with the 7.0 channel uses.

assuming there are no major changes to how this data is stored between now and the releases of dawntrail, you could theoretically begin working now on your own texture mods ready for whenever we get access to 7.0 modding tools. i was able to access these files (and many others) by using XIV data explorer, a program that lets you view and export (but not import!) data directly from specific XIV data indexes.

if you also want to rip textures, the index storing them, alongside skeletons and animations, is 04000.win32.index2. hit ctrl+shift+e to export individual files to a .tex format and then run them through penumbra to convert them into .dds for normals + multis or .png for diffuses for editing. i'm fairly certain that 95% of the pathings will be exactly the same as what penumbra and textools gives us now, so there shouldn't be much need to find entirely new paths.

again, if anyone sees any differences in other races for texture uses or figures out the uses for new channels, PLEASE let me know bc the sooner we get all this figured out the better! i have only been modding for a few years and don't know everything about how every texture works so i'm open to corrections.

[krisp-xyz]

Found your work. You inspired me to take another shot at technical art and graphics programming. Do you recommend any specific resources for getting started and beyond?

Thanks so much! Really glad I could inspire you to do that bc graphics and tech art things are so much fun :D

(Also sorry for the late response. I've been a bit busy and was also thinking about how I wanted to format this)

I'm mostly self taught with a lot of stuff and have done lots of research on a per-project basis, but Acerola and Freya Holmer are two of my favorite channels for learning graphics or technical art things. Shadertoy is also an amazing resource to not only create and view other's shaders, but learn about algorithms and see how people do things!

While I don't have many general resources. I'll steal these resources for graphics programming that Acerola shared in his discord server:

For getting started with graphics engine development: DX11: https://www.rastertek.com/tutdx11s3.html OpenGL: https://learnopengl.com/ DX12: https://learn.microsoft.com/en-us/windows/win32/direct3d12/directx-12-programming-guide Vulkan: https://vulkan-tutorial.com/

For getting started with shaders: catlikecoding: https://catlikecoding.com/unity/tutorials/rendering/ the book of shaders: https://thebookofshaders.com/ daniel ilett's image effects series: https://danielilett.com/2019-04-24-tut1-intro-smo/

For getting started with compute shaders: Kyle Halladay: http://kylehalladay.com/blog/tutorial/2014/06/27/Compute-Shaders-Are-Nifty.html Ronja: https://www.ronja-tutorials.com/post/050-compute-shader/ Three Eyed Games (this one teaches ray tracing AND compute shaders, what a bargain!): http://three-eyed-games.com/2018/05/03/gpu-ray-tracing-in-unity-part-1/

I also wanted to talk a little bit about I do research for projects!

A lot of my proficiency in shaders just comes from practice and slowly building a better understanding of how to best utilize the tools at my disposal, almost like each project is solving a puzzle and I want to find the most optimal solution I can come up with.

This is definitely easier said than done and while a lot of my proficiency comes from just doodling around with projects and practicing, I understand that "just practice more lol" is a boring and kinda unhelpful answer. When it comes to projects like my lighting engine, I came up with a lot of the algorithm stuff myself, but there were certainly lots of details that I learned about from past projects and research like ray marching (calculating the ray intersection of a distance function) and I learned about the jump flood algorithm from a tech artist friend (calculating distance functions from textures)

Each new algorithm you learn in various projects ends up being another tool in your toolbox, and each project becomes a combination of researching new tools and applying the tools you've learned in the past.

One last example. I made a Chladni plate simulation in blender (that thing where you put sand on a metal plate and play noises and it makes patterns) and it started with me researching and looking up chladni plates, I watched youtube videos related to why the sand forms the patterns it does, which ended up being due to how the sound waves displaced the plane. I googled some more and found the actual equation that represents it, and used it to simulate particle motion.

Figure out some projects you want to do and just do some googling or ask for help in game dev discord servers or whatever. Lot's of research on a per-project basis is honestly how you'll learn the most imo :3

[tumatawa]

did you follow any sort of guide when reskinning your computer to vista?

No, but most programs I use have individual guides, Ive put everything below for anyone interested. Make sure to create system restore points before and inbetween, please note Im not a computer guy in the least. I do not have my Windows 10 PC's best interest in mind, and Im actively trying to kill this laptop any way I can.

Start Menu: Vistalike skin on Open Shell. Files are at the bottom of the thread Login: Custom Logon Hook skin for Vista (UNSTABLE, NOT RECOMMENDED. Make sure Ctrl+Alt+Delete is enabled) Theme: Aero10 I use the Vista (shiny) variant. Not compatible with certain screen resolutions. DWMBlurGlass (for window color/opacity) may occasionally stop, I just reapply when it happens. If the program suddenly doesn't open, restarting usually does the trick. Taskbar: StartIsBack for UI, Open Shell for texture + start button. SIB's trial expiration only affects the start menu which I'm already using Open Shell for so its basically free. Uncheck all Switching tab options. For texturing, I just screenshotted a part textured by SIB and made it the taskbar texture on Open Shell. If the taskbar gets mangled for any reason restart File Explorer on Task Manager. Start buttons are an edited version of this, with added space to the right since it overlapped my taskbar items.

Firefox theme: Rinfox only works for Firefox 115/115ESR. Installation guide is in the "rinfox" folder. Extra info. Reshacker directions were in 2 different places so I'll put it all below (RUN AS ADMINISTRATOR):

IE icon (do this first): File > Open > Open firefox.exe > Icon Group tab > Replace icons 1, 2, 5, 32512 with ie.ico either from rinfox's chrome > images folders or just download it online idc Enabling aero: [^ first 3 steps done] > Manifest tab > delete these lines: ```xml <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/> ``` Press compile (Green play button on the right) > Save > Restart Computer

Extras: Win7 tray icons and network flyout (Close enough for me) Customtube / Startube for V3 WLM 2009 Vista Media Player Vista Paint Battery Mode 7 + Taskbar Tweaker Winaero Tweaker (has a lot of Legacy options) Longhorn Sidebar for Rainmeter Windhawk Extentions: Aero Flyout Fix Aero Tray Win32 Tray Clock Experience

[monstersdownthepath]

A weird but curious question similar to one I asked you a long time ago about Outsiders with alignment subtypes that shift alignment, but since the Aeons are supposed to be more or less a cold, unfeeling cosmic collective consciousness/immune system, how do you think What would an Aon with personality would be like? (yes, like an actual individual personality, perhaps even with deep thoughts and feelings beyond his purposes and goals).

Asking this because, at least in my campaign, there is a case of an Aeon whose whole purpose for being summoned is to act as a persistent, free-willed, cosmic observer of certain creatures, but to observe and record the stories and adventures of the creatures he observes, he needed to understand them. He needs to be able to know what they feel and how they feel it, something in which a normal, cold Aon and calculating, it would not be totally good. At least I've played it as someone growing up; At first he was childish, impulsive and curious, but as he distanced himself and learned, he quickly became colder, more mature and wiser, but always referring to himself in plural forms ("we").

Weird question I know! But I would like to read your opinion and response anyway.

------

This is a difficult answer, but not an impossible one. Aeons with so much as individual names are nearly nonexistent, with Concordance of Rivals describing them as though they were forces of nature or wind-up toys rather than individual creatures. Indeed, they essentially are; as you stated, aeons are shed by the Monad as an immune response to an imbalance in the cosmos (or an imbalance fated to occur), and when their duty is complete, they fade back into quintessence to rejoin their creator. Not exactly conducive to the development of individuality or a personality!

Even in cases where their mission takes many decades or centuries to complete, aeons rarely deviate from acting as they've been programmed, spend very little time interacting with other beings (one gets the sense that they communicate only out of obligation, rather than any desire), are incredibly difficult to communicate with due to their Envisaging ability, and are nearly impossible to reason with in any meaningful way.

They possess no society and no individuality. The one named aeon I recalled from the Extinction Curse Adventure Path was given a name by someone else, and its "personality" a mere anthropomorphized projection by that person, rather than the aeon itself having any part in it beyond accepting the name.

However, with the recent retcon revelation that axiomites and, thus, inevitables are themselves descended from aeons sent on a specific mission and grew into an independent society, it lends a lot to your proposed aeon gaining a name and personality for itself. Given enough time and with enough interactions with other beings, one could expect an aeon to change in the same way an emergent AI would if exposed to the same stimulus, with all the same qualities.

... In fact, as I type this with one hand and hold open Concordance of Rivals with the other and stroke my chin thoughtfully with the third, I believe describing aeons as programs, as well as cells, is also an apt summary. I've already called the Monad the "win32 of the multiverse," so it's not that much of a logical leap. I might have to make a second post about this, actually, because the comparison of aeons and machine-learning-AIs is hitting me like a ton of bricks.

[linuxgamenews]

Glorious Eggroll's UMU Unified Launcher: Enhanced Gaming on Linux

UMU Unified Launcher is shaping up to be a solid tool to play games on Linux outside Steam with Proton. Thanks to the creative work of Thomas Crider — better known to fans as Glorious Eggroll. Which is available on GitHub, but let me explain further. If you have yet to learn about this unified launcher, let me introduce you UMU. A very slick tool that makes it easy to launch Windows games on Linux without needing Steam. If you’ve ever wanted to play games from different stores like Epic or GOG on Linux but hated juggling setups, UMU might just be your new best friend. It's built to work just like Proton, Steam's famous compatibility layer for Windows titles, but with a twist. You don't even need Steam installed to use it. The name UMU might sound odd at first, but there's a nice story behind it. An "umu" is a Polynesian above - ground oven that uses hot stones to cook food. This was chosen because Valve’s own tool for Proton is called a “pressure vessel,” so this launcher is the perfect "cooking" setting to support your gaming.

So, What Does UMU Actually Do?

When Steam runs a game with Proton, it goes through a series of setup steps in the background. UMU recreates this setup outside of Steam, using a script that tells Proton everything it needs to run that title. Normally, Steam sends certain environment variables (envvars) to Proton so it can handle Windows titles. This launcher mimics that process, so it’s like having all the benefits of Steam Proton — without Steam. With UMU, you can specify the Proton version, WINEPREFIX (the custom folder where your game settings and files go), the executable (the .exe file for the game). And also any custom launch options. This means you can launch games from any store and they’ll still run through Proton, as if Steam were handling it. No need to add that title to your library or even have Steam installed.

Watch Thomas Crider Glorious Eggroll explain

Getting Started

Setting it up is straightforward. Here’s a basic example: WINEPREFIX=$HOME/Games/epic-games-store GAMEID=umu-dauntless PROTONPATH="$HOME/.steam/steam/compatibilitytools.d/GE-Proton8-28" umu-run "$HOME/Games/epic-games-store/drive_c/Program Files (x86)/Epic Games/Launcher/Portal/Binaries/Win32/EpicGamesLauncher.exe" -opengl -SkipBuildPatchPrereq In this command:

WINEPREFIX tells UMU where your data lives.

GAMEID is the name you give your game in UMU’s system.

PROTONPATH points to your Proton version.

The last part is your path to install files and any launch options like "-opengl."

If you’re using game fixes (protonfixes) or specific store setups, you can add the STORE variable. This lets UMU know which fixes to apply for each title from places like Epic Games Store (EGS) or others. v Now here’s where this unified launcher gets really exciting. Imagine using launchers like Lutris, Bottles, Heroic, and others. All tapping into the same system for Proton fixes. Right now, each launcher might have its own set of scripts to get that title running. But with the unified launcher, they can share a universal setup.

UMU allows all these launchers to:

Use and contribute to a single set of protonfixes. No more maintaining separate setups.

Run games through Proton just like they would on Steam.

Skip installing Steam or any Steam binaries—UMU handles it all.

And since UMU automatically fetches and organizes the latest Steam Runtime files, you’ll always have the most updated setting for Proton, without manual downloads. This is elegant.

Making It All Happen:

To keep things streamlined, UMU’s team plans to build a centralized database. Where each title from various stores can be matched with its unique “umu ID.” Here’s how it could work:

Database Creation: For each title, the database will have details like game title, store, codename, and its UMU ID.

Launcher Integration: When you launch a title from, say, Heroic or Bottles, it can pull the UMU ID from the database.

Proton Fixes: Based on the store and UMU ID, protonfixes will load the right fixes before running the game.

Using the example on Github: Running Borderlands 3

Let’s say you have Borderlands 3 from the Epic Games Store (EGS), which goes by the codename “Catnip.” Your launcher (like Lutris) can search UMU’s database using “Catnip” and EGS as search terms. Which also links it to the UMU ID for Borderlands 3. With that ID, UMU unified launcher will know which fixes to apply, making setup a breeze. So, in a nutshell, UMU unified launcher is like a universal Proton setup for Linux gaming. By setting up Proton outside of Steam, UMU lets you run titles from any store using a consistent setting. Doing so without the hassle of managing separate install scripts or needing Steam. For setup details and learn more, check out the GitHub page. For a quick setup, use Lutris with the tool built in. Thank you Glorious Eggroll and team!!

[this-week-in-rust]

This Week in Rust 534

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Announcing Rust 1.76.0

This Development-cycle in Cargo: 1.77

Project/Tooling Updates

zbus 4.0 released. zbus is a pure Rust D-Bus crate. The new version brings a more ergonomic and safer API. Release: zbus4

This Month in Rust OSDev: January 2024

Rerun 0.13 - real-time kHz time series in a multimodal visualizer

egui 0.26 - Text selection in labels

Hello, Selium! Yet another streaming platform, but easier

Observations/Thoughts

Which red is your function?

Porting libyaml to Safe Rust: Some Thoughts

Design safe collection API with compile-time reference stability in Rust

Cross compiling Rust to win32

Modular: Mojo vs. Rust: is Mojo 🔥 faster than Rust 🦀 ?

Extending Rust's Effect System

Allocation-free decoding with traits and high-ranked trait bounds

Cross-Compiling Your Project in Rust

Kind: Our Rust library that provides zero-cost, type-safe identifiers

Performance Roulette: The Luck of Code Alignment

Too dangerous for C++

Building an Uptime Monitor in Rust

Box Plots at the Olympics

Rust in Production: Interview with FOSSA

Performance Pitfalls of Async Function Pointers (and Why It Might Not Matter)

Error management in Rust, and libs that support it

Finishing Turborepo's migration from Go to Rust

Rust: Reading a file line by line while being mindful of RAM usage

Why Rust? It's the safe choice

[video] Rust 1.76.0: 73 highlights in 24 minutes!

Rust Walkthroughs

Rust/C++ Interop Part 1 - Just the Basics

Rust/C++ Interop Part 2 - CMake

Speeding up data analysis with Rayon and Rust

Calling Rust FFI libraries from Go

Write a simple TCP chat server in Rust

[video] Google Oauth with GraphQL API written in Rust - part 1. Registration mutation.

Miscellaneous

The book "Asynchronous Programming in Rust" is released

January 2024 Rust Jobs Report

Chasing a bug in a SAT solver

Rust for hardware vendors

[audio] How To Secure Your Audio Code Using Rust With Chase Kanipe

[audio] Tweede Golf - Rust in Production Podcast

[video] RustConf 2023

[video] Decrusting the tracing crate

Crate of the Week

This week's crate is microflow, a robust and efficient TinyML inference engine for embedded systems.

Thanks to matteocarnelos for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

* Hyperswitch - [FEATURE]: Setup code coverage for local tests & CI * Hyperswitch - [FEATURE]: Have get_required_value to use ValidationError in OptionExt

If you are a Rust project owner and are looking for contributors, please submit tasks here.

CFP - Speakers

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

Devoxx PL 2024 | CFP closes 2024-03-01 | Krakow, Poland | Event date: 2024-06-19 - 2024-06-21

RustFest Zürich 2024 CFP closes 2024-03-31 | Zürich, Switzerland | Event date: 2024-06-19 - 2024-06-24

If you are an event organizer hoping to expand the reach of your event, please submit a link to the submission website through a PR to TWiR.

Updates from the Rust Project

466 pull requests were merged in the last week

add armv8r-none-eabihf target for the Cortex-R52

add lahfsahf and prfchw target feature

check_consts: fix duplicate errors, make importance consistent

interpret/write_discriminant: when encoding niched variant, ensure the stored value matches

large_assignments: Allow moves into functions

pattern_analysis: gather up place-relevant info

pattern_analysis: track usefulness without interior mutability

account for non-overlapping unmet trait bounds in suggestion

account for unbounded type param receiver in suggestions

add support for custom JSON targets when using build-std

add unstable -Z direct-access-external-data cmdline flag for rustc

allow restricted trait impls under #[allow_internal_unstable(min_specialization)]

always check the result of pthread_mutex_lock

avoid ICE in drop recursion check in case of invalid drop impls

avoid a collection and iteration on empty passes

avoid accessing the HIR in the happy path of coherent_trait

bail out of drop elaboration when encountering error types

build DebugInfo for async closures

check that the ABI of the instance we are inlining is correct

clean inlined type alias with correct param-env

continue to borrowck even if there were previous errors

coverage: split out counter increment sites from BCB node/edge counters

create try_new function for ThinBox

deduplicate tcx.instance_mir(instance) calls in try_instance_mir

don't expect early-bound region to be local when reporting errors in RPITIT well-formedness

don't skip coercions for types with errors

emit a diagnostic for invalid target options

emit more specific diagnostics when enums fail to cast with as

encode coroutine_for_closure for foreign crates

exhaustiveness: prefer "0..MAX not covered" to "_ not covered"

fix ICE for deref coercions with type errors

fix ErrorGuaranteed unsoundness with stash/steal

fix cycle error when a static and a promoted are mutually recursive

fix more ty::Error ICEs in MIR passes

for E0223, suggest associated functions that are similar to the path

for a rigid projection, recursively look at the self type's item bounds to fix the associated_type_bounds feature

gracefully handle non-WF alias in assemble_alias_bound_candidates_recur

harmonize AsyncFn implementations, make async closures conditionally impl Fn* traits

hide impls if trait bound is proven from env

hir: make sure all HirIds have corresponding HIR Nodes

improve 'generic param from outer item' error for Self and inside static/const items

improve normalization of Pointee::Metadata

improve pretty printing for associated items in trait objects

introduce enter_forall to supercede instantiate_binder_with_placeholders

lowering unnamed fields and anonymous adt

make min_exhaustive_patterns match exhaustive_patterns better

make it so that async-fn-in-trait is compatible with a concrete future in implementation

make privacy visitor use types more (instead of HIR)

make traits / trait methods detected by the dead code lint

mark "unused binding" suggestion as maybe incorrect

match lowering: consistently lower bindings deepest-first

merge impl_polarity and impl_trait_ref queries

more internal emit diagnostics cleanups

move path implementations into sys

normalize type outlives obligations in NLL for new solver

print image input file and checksum in CI only

print kind of coroutine closure

properly handle async block and async fn in if exprs without else

provide more suggestions on invalid equality where bounds

record coroutine kind in coroutine generics

remove some unchecked_claim_error_was_emitted calls

resolve: unload speculatively resolved crates before freezing cstore

rework support for async closures; allow them to return futures that borrow from the closure's captures

static mut: allow mutable reference to arbitrary types, not just slices and arrays

stop bailing out from compilation just because there were incoherent traits

suggest [tail @ ..] on [..tail] and [...tail] where tail is unresolved

suggest less bug-prone construction of Duration in docs

suggest name value cfg when only value is used for check-cfg

suggest pattern tests when modifying exhaustiveness

suggest turning if let into irrefutable let if appropriate

suppress suggestions in derive macro

take empty where bounds into account when suggesting predicates

toggle assert_unsafe_precondition in codegen instead of expansion

turn the "no saved object file in work product" ICE into a translatable fatal error

warn on references casting to bigger memory layout

unstably allow constants to refer to statics and read from immutable statics

use the same mir-opt bless targets on all platforms

enable MIR JumpThreading by default

fix mir pass ICE in the presence of other errors

miri: fix ICE with symbolic alignment check on extern static

miri: implement the mmap64 foreign item

prevent running some code if it is already in the map

A trait's local impls are trivially coherent if there are no impls

use ensure when the result of the query is not needed beyond its Resultness

implement SystemTime for UEFI

implement sys/thread for UEFI

core/time: avoid divisions in Duration::new

core: add Duration constructors

make NonZero constructors generic

reconstify Add

replace pthread RwLock with custom implementation

simd intrinsics: add simd_shuffle_generic and other missing intrinsics

cargo: test-support: remove special case for $message_type

cargo: don't add the new package to workspace.members if there is no existing workspace in Cargo.toml

cargo: enable edition migration for 2024

cargo: feat: add hint for adding members to workspace

cargo: fix confusing error messages for sparse index replaced source

cargo: fix: don't duplicate comments when editing TOML

cargo: relax a test to permit warnings to be emitted, too

rustdoc: Correctly generate path for non-local items in source code pages

bindgen: add target mappings for riscv64imac and riscv32imafc

bindgen: feat: add headers option

clippy: mem_replace_with_default No longer triggers on unused expression

clippy: similar_names: don't raise if the first character is different

clippy: to_string_trait_impl: avoid linting if the impl is a specialization

clippy: unconditional_recursion: compare by Tys instead of DefIds

clippy: don't allow derive macros to silence disallowed_macros

clippy: don't lint incompatible_msrv in test code

clippy: extend NONMINIMAL_BOOL lint

clippy: fix broken URL in Lint Configuration

clippy: fix false positive in redundant_type_annotations lint

clippy: add autofixes for unnecessary_fallible_conversions

clippy: fix: ICE when array index exceeds usize

clippy: refactor implied_bounds_in_impls lint

clippy: return Some from walk_to_expr_usage more

clippy: stop linting blocks_in_conditions on match with weird attr macro case

rust-analyzer: abstract more over ItemTreeLoc-like structs

rust-analyzer: better error message for when proc-macros have not yet been built

rust-analyzer: add "unnecessary else" diagnostic and fix

rust-analyzer: add break and return postfix keyword completions

rust-analyzer: add diagnostic with fix to replace trailing return <val>; with <val>

rust-analyzer: add incorrect case diagnostics for traits and their associated items

rust-analyzer: allow cargo check to run on only the current package

rust-analyzer: completion list suggests constructor like & builder methods first

rust-analyzer: improve support for ignored proc macros

rust-analyzer: introduce term search to rust-analyzer

rust-analyzer: create UnindexedProject notification to be sent to the client

rust-analyzer: substitute $saved_file in custom check commands

rust-analyzer: fix incorrect inlining of functions that come from MBE macros

rust-analyzer: waker_getters tracking issue from 87021 for 96992

rust-analyzer: fix macro transcriber emitting incorrect lifetime tokens

rust-analyzer: fix target layout fetching

rust-analyzer: fix tuple structs not rendering visibility in their fields

rust-analyzer: highlight rustdoc

rust-analyzer: preserve where clause when builtin derive

rust-analyzer: recover from missing argument in call expressions

rust-analyzer: remove unnecessary .as_ref() in generate getter assist

rust-analyzer: validate literals in proc-macro-srv FreeFunctions::literal_from_str

rust-analyzer: implement literal_from_str for proc macro server

rust-analyzer: implement convert to guarded return assist for let statement with type that implements std::ops::Try

Rust Compiler Performance Triage

Relatively balanced results this week, with more improvements than regressions. Some of the larger regressions are not relevant, however there was a real large regression on doc builds, that was caused by a correctness fix (rustdoc was doing the wrong thing before).

Triage done by @kobzol. Revision range: 0984becf..74c3f5a1

Summary:

(instructions:u) mean range count Regressions ❌ (primary) 2.1% [0.2%, 12.0%] 44 Regressions ❌ (secondary) 5.2% [0.2%, 20.1%] 76 Improvements ✅ (primary) -0.7% [-2.4%, -0.2%] 139 Improvements ✅ (secondary) -1.3% [-3.3%, -0.3%] 86 All ❌✅ (primary) -0.1% [-2.4%, 12.0%] 183

6 Regressions, 5 Improvements, 8 Mixed; 5 of them in rollups 53 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

eRFC: Iterate on and stabilize libtest's programmatic output

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

RFC: Rust Has Provenance

Tracking Issues & PRs

Rust

[disposition: close] Implement Future for Option<F>

[disposition: merge] Tracking Issue for min_exhaustive_patterns

[disposition: merge] Make unsafe_op_in_unsafe_fn warn-by-default starting in 2024 edition

Cargo

[disposition: merge] feat: respect rust-version when generating lockfile

New and Updated RFCs

No New or Updated RFCs were created this week.

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

RFC: Checking conditional compilation at compile time

Testing steps

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2024-02-14 - 2024-03-13 💕 🦀 💕

Virtual

2024-02-15 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn

2024-02-15 | Virtual + In person (Praha, CZ) | Rust Czech Republic

Introduction and Rust in production

2024-02-19 | Virtual (Melbourne, VIC, AU)| Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 1

2024-02-20 | Virtual (Melbourne, VIC, AU) | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 2

2024-02-20 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2024-02-20 | Virtual | Rust for Lunch

Lunch

2024-02-21 | Virtual (Cardiff, UK) | Rust and C++ Cardiff

Rust for Rustaceans Book Club: Chapter 2 - Types

2024-02-21 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2024-02-22 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-02-27 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2024-02-29 | Virtual (Berlin, DE) | OpenTechSchool Berlin + Rust Berlin

Rust Hack and Learn | Mirror: Rust Hack n Learn Meetup | Mirror: Berline.rs page

2024-02-29 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Surfing the Rusty Wireless Waves with the ESP32-C3 Board

2024-03-06 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2024-03-07 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2024-03-12 | Virtual (Dallas, TX, US) | Dallas Rust

Second Tuesday

2024-03-12 | Hybrid (Virtual + In-person) Munich, DE | Rust Munich

Rust Munich 2024 / 1 - hybrid

Asia

2024-02-17 | New Delhi, IN | Rust Delhi

Meetup #5

Europe

2024-02-15 | Copenhagen, DK | Copenhagen Rust Community

Rust Hacknight #2: Compilers

2024-02-15 | Praha, CZ - Virtual + In-person | Rust Czech Republic

Introduction and Rust in production

2024-02-21 | Lyon, FR | Rust Lyon

Rust Lyon Meetup #8

2024-02-22 | Aarhus, DK | Rust Aarhus

Rust and Talk at Partisia

2024-02-29 | Berlin, DE | Rust Berlin

Rust and Tell - Season start 2024

2024-03-12 | Munich, DE + Virtual | Rust Munich

Rust Munich 2024 / 1 - hybrid

North America

2024-02-15 | Boston, MA, US | Boston Rust Meetup

Back Bay Rust Lunch, Feb 15

2024-02-15 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group Meetup

2024-02-20 | New York, NY, US | Rust NYC

Rust NYC Monthly Mixer (Moved to Feb 20th)

2024-02-20 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2024-02-21 | Boston, MA, US | Boston Rust Meetup

Evening Boston Rust Meetup at Microsoft, February 21

2024-02-22 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2024-02-28 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2024-03-07 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

Oceania

2024-02-19 | Melbourne, VIC, AU + Virtual | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 1

2024-02-20 | Melbourne, VIC, AU + Virtual | Rust Melbourne

(Hybrid - in person & online) February 2024 Rust Melbourne Meetup - Day 2

2024-02-27 | Canberra, ACT, AU | Canberra Rust User Group

February Meetup

2024-02-27 | Sydney, NSW, AU | Rust Sydney

🦀 spire ⚡ & Quick

2024-03-05 | Auckland, NZ | Rust AKL

Rust AKL: Introduction to Embedded Rust + The State of Rust UI

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

For some weird reason the Elixir Discord community has a distinct lack of programmer-socks-wearing queer furries, at least compared to Rust, or even most other tech-y Discord servers I’ve seen. It caused some weird cognitive dissonance. Why do I feel vaguely strange hanging out online with all these kind, knowledgeable, friendly and compassionate techbro’s? Then I see a name I recognized from elsewhere and my hindbrain goes “oh thank gods, I know for a fact she’s actually a snow leopard in her free time”. Okay, this nitpick is firmly tongue-in-cheek, but the Rust user-base continues to be a fascinating case study in how many weirdos you can get together in one place when you very explicitly say it’s ok to be a weirdo.

– SimonHeath on the alopex Wiki's ElixirNitpicks page

Thanks to Brian Kung for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[indirect]

I got an email about my Win32 programming tutorial (circa 1999) from a 12 year old girl whose hobby is making "programs in languages used way before i was born" ...First of all yes, excellent, this is a good hobby.Secondly, don't mind me, I'll just be over here crumbling to dust. :blobimfine:

@brook

[shwoo]

I've been fighting Windows' API trying to make a simple program before tomorrow night because I volunteered to do a trivia thing for my family, and I thought it would help with organising the questions and scores. I already have the questions, so it's not a huge problem if it's not finished in time.

I just wanted some form controls, like buttons and stuff, but I'm not that familiar with doing that in Visual Studio with C++. And the information on Microsoft's site is extensive, but... convenient (missing a lot of important information). I learned Win32 programming about a year ago, so I might have also forgotten something important that wasn't mentioned in the documentation I'm using at the moment.

And I could not get a control defined in the code to show up. I didn't want to use the resources for a lot of reasons, even once I figured out how to bypass the kind of stripped down visual editor, but I also couldn't seem to program a button in directly and have it appear in the window when I ran the program. It seemed to be created fine, but I couldn't see it anywhere.

I finally found some example code on Stack Overflow or somewhere, and the reason the button wasn't showing up was because... I hadn't specified the WS_VISIBLE flag when I created it. (WS stands for Window Style. Win32 has a very broad definition of a window that includes buttons) Apparently it's programmed in a way that assumes that an object invisible until you tell it that it's not? I would've done it the other way around.

I had to sit there for a few seconds after I added it in and the button finally showed up. At least it's progress?

[govindhtech]

Analyzing C2C Communications In Financial Malware

As Ursa, the remote overlay financial malware Mispadu targets banks in Spanish- and Portuguese-speaking countries like Mexico, Colombia, Argentina, Chile, Portugal, Spain, and others. Remote overlay malware is a malicious program that controls a victim's keyboard and mouse while the fraudster observes their live screen.

Control and command When Mispadu reopened, C2C communications encoding was changed.

Preparing C2C communications

Goal of C2C communications

The assault relies on the malware's remote overlay communication with its operator. This connection is used by the fraudster to deliver operational orders to the victim's infected application.

While monitoring the victim's live sessions, the fraudster performs many overlay attacks, such as bank account theft.

C2C connection timing

The scammer does not contact the victim immediately after the victim launches the infected app, despite appearances. Such touch may trigger antivirus software alerts, endangering the fraudster.

In scenario and most other remote overlay scenarios, communication begins when the user hits one of the malware's targets, Spanish- or Portuguese-speaking bank websites.

Initialising C2C communications

The user contacts the C2C server when seeing a virus target list. WIN32 Socket APIs, the most practical way to connect, are used.

Before configuring the socket, the virus enters its IP and destination port.

Receive C2C messages

When the socket is linked and the beacon is sent, the malware awaits C2C server input. Once received, “read” functions handle the message based on its sequence:

These similar algorithms parse C2C communications.

First, “TwYHJk1_wC51Read,” will be discussed:

After receiving a message from the C2C, the virus decodes and compares it to a command string. “|SocketMain|>” is the first compared command in the first “read” function. Other “read” functions provide different comparison instructions.

Note the function at 0x7364A8.

This function must decipher the complete message. The program decodes a string using mathematical processes.

Check out that function's operation.

Encoding C2C messages

Goal

Communication encoding hides fraudulent goals and techniques. This can be done with current or custom communication algorithms. As seen, “GFHHV..” appears encoded because it seems random and meaningless.

Execution

The C2C communications decoding function is simple and decodes C2C server messages. The same encoder is used for C2C server messages.

Decoding will be broken down into these steps:

Convert the first character (“G”GFHHVGCGEFUGAFOFUGCFMFXHVFJ@) to ASCII. The value is 71. Subtract 65 (ASCII “A”) from this number. The result is 6.

Let's revisit 6 later because it repeats value while decoding.

Step 2: ASCII the character (“F” GFHHVGCGEFUGAFOFUGCFMFXHVFJ@). It's worth 70. Remove 65, the ASCII code for “A.” The result is five. Assume X is variable. The two assembly code lines can be represented by this equation:

4X + 4X4 = 25X = 255 = 125

Step 3: Choose the ASCII value for “H”: 72. Subtract “A” from ASCII: outcome 7. Add the previous step's result. 125+7=132. Remove step 1's result and 66 (‘B’) from it. 60 = 132-66-6. “<” in ASCII. First character in decoded string.

Step 4: Repeat Steps 2 and 3 with the next set of characters (“H” & “V” GFHHVG..), attaching the decoded character each time to form the string.

Step 5: String ends with “@” GFHHVGCGEFUGAFOFUGCFMFXHVFJ@. Decoding the encoded text may display the result: |PRINCIPAL|> The malware submitted this string to the C2C server initially.

Something to remember

Encoding and decoding can create the same character from different encoded characters.

AFV and GGC map to P.

A more complicated example follows. The same plaintext may be retrieved by decoding “GFHHVGCGEFUGAFOFUGCFMFXHVFJ” and “AFBHPFVFXFOFTFIFOFVFGFRHPFD.”

If the network is monitored, such encoding and decoding methods make it difficult to understand the malware's behaviour without the decoding algorithm. Because each command has many encoding options, the malware's comparable mode of operation appears unique to the network monitor each time.

C2C instructions

Execution

The sample's next steps are simple after deciphering the instruction. The fraudster can control the victim's mouse, keyboard, and screen, among other things, because each command has a specific operating role.

Main commands

The infection has set up commands for the scammer to perform various tasks on the victim's PC.

A beacon, denoted by “<|PRINCIPAL|>,” is delivered by the virus to the C2C server to indicate network establishment.

Following this first stage, the fraudster has full control over the victim's system and can take any action. Extraction of critical system data is crucial. Using the “<|Info|>” command, basic system information about the victim can be exported. The Windows version, location, browser, and webpage are listed. Malware's example response to this command sent back to the C2C server:

“Info: Chrome, Bank xWin 10At 4:04:12 PM.

This answer says the victim is reading Bank x's homepage on Windows 10 and Chrome at 4:04:12 PM.

This data is stolen for many reasons. Knowing the victim's operating system may make it easier to infiltrate their system with additional malicious tools. Knowing the victim's intended bank site helps the fraudster perform the attack.

Conclusion

Today, remote overlay attacks are one of the most common threats to bank accounts, endangering banks and their clients. These attacks depend on malware-operator communication, which is vital to their strategy. Such assaults require real-time contact. The virus encrypts communication to strengthen its defences and make it harder to reverse. As cybersecurity experts, IBM monitors, examines, and stops these transactions to prevent fraud.

Staying safe

For safety, users should routinely check their apps and uninstall any that seem odd or dangerous.

Unauthorised transactions in cryptocurrency wallets and unexpected login attempts in email accounts should also be checked. Being aware and proactive helps decrease the risks of this evolving assault paradigm.

IBM Trusteer helps you authenticate people, prevent fraud and malware, and build identity trust across the omnichannel consumer experience. Over 500 top firms utilise IBM Trusteer to expand and protect client digital experiences.

For more details visit govindhtech.com